<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE GADTs, UndecidableInstances #-}</span><span>
</span><span id="line-2"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-3"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-4"></span><span class="hs-comment">-- Module      :  Distribution.Compat.Parsing</span><span>
</span><span id="line-5"></span><span class="hs-comment">-- Copyright   :  (c) Edward Kmett 2011-2012</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- License     :  BSD3</span><span>
</span><span id="line-7"></span><span class="hs-comment">--</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Maintainer  :  ekmett@gmail.com</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- Stability   :  experimental</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Portability :  non-portable</span><span>
</span><span id="line-11"></span><span class="hs-comment">--</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Alternative parser combinators.</span><span>
</span><span id="line-13"></span><span class="hs-comment">--</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- Originally in @parsers@ package.</span><span>
</span><span id="line-15"></span><span class="hs-comment">--</span><span>
</span><span id="line-16"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-17"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Distribution.Compat.Parsing</span><span>
</span><span id="line-18"></span><span>  </span><span class="hs-special">(</span><span>
</span><span id="line-19"></span><span>  </span><span class="annot"><span class="hs-comment">-- * Parsing Combinators</span></span><span>
</span><span id="line-20"></span><span>    </span><span class="annot"><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier">choice</span></a></span><span>
</span><span id="line-21"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#option"><span class="hs-identifier">option</span></a></span><span>
</span><span id="line-22"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier">optional</span></a></span><span> </span><span class="hs-comment">-- from Control.Applicative, parsec optionMaybe</span><span>
</span><span id="line-23"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipOptional"><span class="hs-identifier">skipOptional</span></a></span><span> </span><span class="hs-comment">-- parsec optional</span><span>
</span><span id="line-24"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#between"><span class="hs-identifier">between</span></a></span><span>
</span><span id="line-25"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#some"><span class="hs-identifier">some</span></a></span><span>     </span><span class="hs-comment">-- from Control.Applicative, parsec many1</span><span>
</span><span id="line-26"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier">many</span></a></span><span>     </span><span class="hs-comment">-- from Control.Applicative</span><span>
</span><span id="line-27"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-identifier">sepBy</span></a></span><span>
</span><span id="line-28"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier">sepByNonEmpty</span></a></span><span>
</span><span id="line-29"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier">sepEndByNonEmpty</span></a></span><span>
</span><span id="line-30"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-identifier">sepEndBy</span></a></span><span>
</span><span id="line-31"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#endByNonEmpty"><span class="hs-identifier">endByNonEmpty</span></a></span><span>
</span><span id="line-32"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#endBy"><span class="hs-identifier">endBy</span></a></span><span>
</span><span id="line-33"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#count"><span class="hs-identifier">count</span></a></span><span>
</span><span id="line-34"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl"><span class="hs-identifier">chainl</span></a></span><span>
</span><span id="line-35"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr"><span class="hs-identifier">chainr</span></a></span><span>
</span><span id="line-36"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl1"><span class="hs-identifier">chainl1</span></a></span><span>
</span><span id="line-37"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr1"><span class="hs-identifier">chainr1</span></a></span><span>
</span><span id="line-38"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#manyTill"><span class="hs-identifier">manyTill</span></a></span><span>
</span><span id="line-39"></span><span>  </span><span class="annot"><span class="hs-comment">-- * Parsing Class</span></span><span>
</span><span id="line-40"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier">Parsing</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>
</span><span id="line-41"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-42"></span><span>
</span><span id="line-43"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-44"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Distribution.Compat.Prelude.html"><span class="hs-identifier">Distribution.Compat.Prelude</span></a></span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#"><span class="hs-identifier">Control.Applicative</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#%3C%2A%2A%3E"><span class="hs-operator">(&lt;**&gt;)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#optional"><span class="hs-identifier">optional</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-47"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Class.html#"><span class="hs-identifier">Control.Monad.Trans.Class</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier">lift</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-48"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.State.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-49"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.State.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-50"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.Writer.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-51"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.Writer.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#"><span class="hs-identifier">Control.Monad.Trans.RWS.Lazy</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Lazy</span></span><span>
</span><span id="line-53"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#"><span class="hs-identifier">Control.Monad.Trans.RWS.Strict</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Strict</span></span><span>
</span><span id="line-54"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#"><span class="hs-identifier">Control.Monad.Trans.Reader</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier">ReaderT</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-55"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#"><span class="hs-identifier">Control.Monad.Trans.Identity</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier">IdentityT</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-56"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Foldable.html#"><span class="hs-identifier">Data.Foldable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Foldable.html#asum"><span class="hs-identifier">asum</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-57"></span><span>
</span><span id="line-58"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../base/src/Data.List.NonEmpty.html#"><span class="hs-identifier">Data.List.NonEmpty</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">NE</span></span><span>
</span><span id="line-59"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../parsec/src/Text.Parsec.html#"><span class="hs-identifier">Text.Parsec</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Parsec</span></span><span>
</span><span id="line-60"></span><span>
</span><span id="line-61"></span><span class="hs-comment">-- | @choice ps@ tries to apply the parsers in the list @ps@ in order,</span><span>
</span><span id="line-62"></span><span class="hs-comment">-- until one of them succeeds. Returns the value of the succeeding</span><span>
</span><span id="line-63"></span><span class="hs-comment">-- parser.</span><span>
</span><span id="line-64"></span><span id="local-6989586621679624563"><span id="local-6989586621679624564"><span class="annot"><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-type">choice</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624564"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624564"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624563"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624564"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624563"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-65"></span><span id="choice"><span class="annot"><span class="annottext">choice :: forall (m :: * -&gt; *) a. Alternative m =&gt; [m a] -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-identifier hs-var hs-var">choice</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m a] -&gt; m a
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Foldable t, Alternative f) =&gt;
t (f a) -&gt; f a
</span><a href="../../base/src/Data.Foldable.html#asum"><span class="hs-identifier hs-var">asum</span></a></span><span>
</span><span id="line-66"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#choice"><span class="hs-pragma hs-type">choice</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-67"></span><span>
</span><span id="line-68"></span><span class="hs-comment">-- | @option x p@ tries to apply parser @p@. If @p@ fails without</span><span>
</span><span id="line-69"></span><span class="hs-comment">-- consuming input, it returns the value @x@, otherwise the value</span><span>
</span><span id="line-70"></span><span class="hs-comment">-- returned by @p@.</span><span>
</span><span id="line-71"></span><span class="hs-comment">--</span><span>
</span><span id="line-72"></span><span class="hs-comment">-- &gt;  priority = option 0 (digitToInt &lt;$&gt; digit)</span><span>
</span><span id="line-73"></span><span id="local-6989586621679624556"><span id="local-6989586621679624557"><span class="annot"><a href="Distribution.Compat.Parsing.html#option"><span class="hs-identifier hs-type">option</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624557"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624556"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624557"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624556"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624557"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624556"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-74"></span><span id="option"><span class="annot"><span class="annottext">option :: forall (m :: * -&gt; *) a. Alternative m =&gt; a -&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#option"><span class="hs-identifier hs-var hs-var">option</span></a></span></span><span> </span><span id="local-6989586621679624171"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624171"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span id="local-6989586621679624170"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624170"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624170"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; m a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624171"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-75"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#option"><span class="hs-pragma hs-type">option</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span class="hs-comment">-- | @skipOptional p@ tries to apply parser @p@.  It will parse @p@ or nothing.</span><span>
</span><span id="line-78"></span><span class="hs-comment">-- It only fails if @p@ fails after consuming input. It discards the result</span><span>
</span><span id="line-79"></span><span class="hs-comment">-- of @p@. (Plays the role of parsec's optional, which conflicts with Applicative's optional)</span><span>
</span><span id="line-80"></span><span id="local-6989586621679624548"><span id="local-6989586621679624549"><span class="annot"><a href="Distribution.Compat.Parsing.html#skipOptional"><span class="hs-identifier hs-type">skipOptional</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624549"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624549"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624548"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624549"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span><span>
</span><span id="line-81"></span><span id="skipOptional"><span class="annot"><span class="annottext">skipOptional :: forall (m :: * -&gt; *) a. Alternative m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipOptional"><span class="hs-identifier hs-var hs-var">skipOptional</span></a></span></span><span> </span><span id="local-6989586621679624162"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624162"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">() -&gt; m a -&gt; m ()
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624162"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">() -&gt; m ()
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-82"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipOptional"><span class="hs-pragma hs-type">skipOptional</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-83"></span><span>
</span><span id="line-84"></span><span class="hs-comment">-- | @between open close p@ parses @open@, followed by @p@ and @close@.</span><span>
</span><span id="line-85"></span><span class="hs-comment">-- Returns the value returned by @p@.</span><span>
</span><span id="line-86"></span><span class="hs-comment">--</span><span>
</span><span id="line-87"></span><span class="hs-comment">-- &gt;  braces  = between (symbol &quot;{&quot;) (symbol &quot;}&quot;)</span><span>
</span><span id="line-88"></span><span id="local-6989586621679624539"><span id="local-6989586621679624540"><span id="local-6989586621679624541"><span id="local-6989586621679624542"><span class="annot"><a href="Distribution.Compat.Parsing.html#between"><span class="hs-identifier hs-type">between</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624542"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624542"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624541"><span class="hs-identifier hs-type">bra</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624542"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624540"><span class="hs-identifier hs-type">ket</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624542"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624539"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624542"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624539"><span class="hs-identifier hs-type">a</span></a></span></span></span></span></span><span>
</span><span id="line-89"></span><span id="between"><span class="annot"><span class="annottext">between :: forall (m :: * -&gt; *) bra ket a.
Applicative m =&gt;
m bra -&gt; m ket -&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#between"><span class="hs-identifier hs-var hs-var">between</span></a></span></span><span> </span><span id="local-6989586621679624157"><span class="annot"><span class="annottext">m bra
</span><a href="#local-6989586621679624157"><span class="hs-identifier hs-var">bra</span></a></span></span><span> </span><span id="local-6989586621679624156"><span class="annot"><span class="annottext">m ket
</span><a href="#local-6989586621679624156"><span class="hs-identifier hs-var">ket</span></a></span></span><span> </span><span id="local-6989586621679624155"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624155"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m bra
</span><a href="#local-6989586621679624157"><span class="hs-identifier hs-var">bra</span></a></span><span> </span><span class="annot"><span class="annottext">m bra -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624155"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ket -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m ket
</span><a href="#local-6989586621679624156"><span class="hs-identifier hs-var">ket</span></a></span><span>
</span><span id="line-90"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#between"><span class="hs-pragma hs-type">between</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-91"></span><span>
</span><span id="line-92"></span><span class="hs-comment">-- | @sepBy p sep@ parses /zero/ or more occurrences of @p@, separated</span><span>
</span><span id="line-93"></span><span class="hs-comment">-- by @sep@. Returns a list of values returned by @p@.</span><span>
</span><span id="line-94"></span><span class="hs-comment">--</span><span>
</span><span id="line-95"></span><span class="hs-comment">-- &gt;  commaSep p  = p `sepBy` (symbol &quot;,&quot;)</span><span>
</span><span id="line-96"></span><span id="local-6989586621679624528"><span id="local-6989586621679624529"><span id="local-6989586621679624530"><span class="annot"><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-identifier hs-type">sepBy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624530"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624530"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624529"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624530"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624528"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624530"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624529"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-97"></span><span id="sepBy"><span class="annot"><span class="annottext">sepBy :: forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-identifier hs-var hs-var">sepBy</span></a></span></span><span> </span><span id="local-6989586621679624144"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624144"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624143"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624143"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#toList"><span class="hs-identifier hs-var">toList</span></a></span><span> </span><span class="annot"><span class="annottext">(NonEmpty a -&gt; [a]) -&gt; m (NonEmpty a) -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m sep -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var">sepByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624144"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624143"><span class="hs-identifier hs-var">sep</span></a></span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-98"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepBy"><span class="hs-pragma hs-type">sepBy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-99"></span><span>
</span><span id="line-100"></span><span class="hs-comment">-- | @sepByNonEmpty p sep@ parses /one/ or more occurrences of @p@, separated</span><span>
</span><span id="line-101"></span><span class="hs-comment">-- by @sep@. Returns a non-empty list of values returned by @p@.</span><span>
</span><span id="line-102"></span><span id="local-6989586621679624516"><span id="local-6989586621679624517"><span id="local-6989586621679624518"><span class="annot"><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-type">sepByNonEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624518"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624518"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624517"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624518"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624516"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624518"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624517"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-103"></span><span id="sepByNonEmpty"><span class="annot"><span class="annottext">sepByNonEmpty :: forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-identifier hs-var hs-var">sepByNonEmpty</span></a></span></span><span> </span><span id="local-6989586621679624133"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624133"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624132"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624132"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; NonEmpty a
forall a. a -&gt; [a] -&gt; NonEmpty a
</span><a href="../../base/src/GHC.Base.html#%3A%7C"><span class="hs-operator hs-var">(:|)</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; [a] -&gt; NonEmpty a) -&gt; m a -&gt; m ([a] -&gt; NonEmpty a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624133"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m ([a] -&gt; NonEmpty a) -&gt; m [a] -&gt; m (NonEmpty a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624132"><span class="hs-identifier hs-var">sep</span></a></span><span> </span><span class="annot"><span class="annottext">m sep -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624133"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-104"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepByNonEmpty"><span class="hs-pragma hs-type">sepByNonEmpty</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-105"></span><span>
</span><span id="line-106"></span><span class="hs-comment">-- | @sepEndByNonEmpty p sep@ parses /one/ or more occurrences of @p@,</span><span>
</span><span id="line-107"></span><span class="hs-comment">-- separated and optionally ended by @sep@. Returns a non-empty list of values</span><span>
</span><span id="line-108"></span><span class="hs-comment">-- returned by @p@.</span><span>
</span><span id="line-109"></span><span id="local-6989586621679624128"><span id="local-6989586621679624129"><span id="local-6989586621679624130"><span class="annot"><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier hs-type">sepEndByNonEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624130"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624130"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624129"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624130"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624128"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624130"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624129"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-110"></span><span id="sepEndByNonEmpty"><span class="annot"><span class="annottext">sepEndByNonEmpty :: forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier hs-var hs-var">sepEndByNonEmpty</span></a></span></span><span> </span><span id="local-6989586621679624118"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624118"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624117"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624117"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; NonEmpty a
forall a. a -&gt; [a] -&gt; NonEmpty a
</span><a href="../../base/src/GHC.Base.html#%3A%7C"><span class="hs-operator hs-var">(:|)</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; [a] -&gt; NonEmpty a) -&gt; m a -&gt; m ([a] -&gt; NonEmpty a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624118"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m ([a] -&gt; NonEmpty a) -&gt; m [a] -&gt; m (NonEmpty a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624117"><span class="hs-identifier hs-var">sep</span></a></span><span> </span><span class="annot"><span class="annottext">m sep -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m sep -&gt; m [a]
forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-identifier hs-var">sepEndBy</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624118"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624117"><span class="hs-identifier hs-var">sep</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-111"></span><span>
</span><span id="line-112"></span><span class="hs-comment">-- | @sepEndBy p sep@ parses /zero/ or more occurrences of @p@,</span><span>
</span><span id="line-113"></span><span class="hs-comment">-- separated and optionally ended by @sep@, ie. haskell style</span><span>
</span><span id="line-114"></span><span class="hs-comment">-- statements. Returns a list of values returned by @p@.</span><span>
</span><span id="line-115"></span><span class="hs-comment">--</span><span>
</span><span id="line-116"></span><span class="hs-comment">-- &gt;  haskellStatements  = haskellStatement `sepEndBy` semi</span><span>
</span><span id="line-117"></span><span id="local-6989586621679624114"><span id="local-6989586621679624115"><span id="local-6989586621679624116"><span class="annot"><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-identifier hs-type">sepEndBy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624115"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624114"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624116"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624115"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-118"></span><span id="sepEndBy"><span class="annot"><span class="annottext">sepEndBy :: forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-identifier hs-var hs-var">sepEndBy</span></a></span></span><span> </span><span id="local-6989586621679624105"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624105"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624104"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624104"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">NonEmpty a -&gt; [a]
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; [a]
</span><a href="../../base/src/Data.Foldable.html#toList"><span class="hs-identifier hs-var">toList</span></a></span><span> </span><span class="annot"><span class="annottext">(NonEmpty a -&gt; [a]) -&gt; m (NonEmpty a) -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m sep -&gt; m (NonEmpty a)
forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#sepEndByNonEmpty"><span class="hs-identifier hs-var">sepEndByNonEmpty</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624105"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624104"><span class="hs-identifier hs-var">sep</span></a></span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-119"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#sepEndBy"><span class="hs-pragma hs-type">sepEndBy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-120"></span><span>
</span><span id="line-121"></span><span class="hs-comment">-- | @endByNonEmpty p sep@ parses /one/ or more occurrences of @p@, separated</span><span>
</span><span id="line-122"></span><span class="hs-comment">-- and ended by @sep@. Returns a non-empty list of values returned by @p@.</span><span>
</span><span id="line-123"></span><span id="local-6989586621679624101"><span id="local-6989586621679624102"><span id="local-6989586621679624103"><span class="annot"><a href="Distribution.Compat.Parsing.html#endByNonEmpty"><span class="hs-identifier hs-type">endByNonEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624103"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624103"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624102"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624103"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624101"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624103"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624102"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-124"></span><span id="endByNonEmpty"><span class="annot"><span class="annottext">endByNonEmpty :: forall (m :: * -&gt; *) a sep.
Alternative m =&gt;
m a -&gt; m sep -&gt; m (NonEmpty a)
</span><a href="Distribution.Compat.Parsing.html#endByNonEmpty"><span class="hs-identifier hs-var hs-var">endByNonEmpty</span></a></span></span><span> </span><span id="local-6989586621679624096"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624096"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624095"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624095"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (NonEmpty a)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f (NonEmpty a)
</span><a href="../../base/src/Data.List.NonEmpty.html#some1"><span class="hs-identifier hs-var">NE.some1</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624096"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m sep -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624095"><span class="hs-identifier hs-var">sep</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-125"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#endByNonEmpty"><span class="hs-pragma hs-type">endByNonEmpty</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-126"></span><span>
</span><span id="line-127"></span><span class="hs-comment">-- | @endBy p sep@ parses /zero/ or more occurrences of @p@, separated</span><span>
</span><span id="line-128"></span><span class="hs-comment">-- and ended by @sep@. Returns a list of values returned by @p@.</span><span>
</span><span id="line-129"></span><span class="hs-comment">--</span><span>
</span><span id="line-130"></span><span class="hs-comment">-- &gt;   cStatements  = cStatement `endBy` semi</span><span>
</span><span id="line-131"></span><span id="local-6989586621679624091"><span id="local-6989586621679624092"><span id="local-6989586621679624093"><span class="annot"><a href="Distribution.Compat.Parsing.html#endBy"><span class="hs-identifier hs-type">endBy</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624093"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624093"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624092"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624093"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624091"><span class="hs-identifier hs-type">sep</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624093"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624092"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-132"></span><span id="endBy"><span class="annot"><span class="annottext">endBy :: forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#endBy"><span class="hs-identifier hs-var hs-var">endBy</span></a></span></span><span> </span><span id="local-6989586621679624086"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624086"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624085"><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624085"><span class="hs-identifier hs-var">sep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624086"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m sep -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%2A"><span class="hs-operator hs-var">&lt;*</span></a></span><span> </span><span class="annot"><span class="annottext">m sep
</span><a href="#local-6989586621679624085"><span class="hs-identifier hs-var">sep</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-133"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#endBy"><span class="hs-pragma hs-type">endBy</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-134"></span><span>
</span><span id="line-135"></span><span class="hs-comment">-- | @count n p@ parses @n@ occurrences of @p@. If @n@ is smaller or</span><span>
</span><span id="line-136"></span><span class="hs-comment">-- equal to zero, the parser equals to @return []@. Returns a list of</span><span>
</span><span id="line-137"></span><span class="hs-comment">-- @n@ values returned by @p@.</span><span>
</span><span id="line-138"></span><span id="local-6989586621679624492"><span id="local-6989586621679624493"><span class="annot"><a href="Distribution.Compat.Parsing.html#count"><span class="hs-identifier hs-type">count</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624493"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624493"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624492"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624493"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624492"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span><span>
</span><span id="line-139"></span><span id="count"><span class="annot"><span class="annottext">count :: forall (m :: * -&gt; *) a. Applicative m =&gt; Int -&gt; m a -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#count"><span class="hs-identifier hs-var hs-var">count</span></a></span></span><span> </span><span id="local-6989586621679624075"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679624075"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679624074"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624074"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679624075"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m [a]
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-140"></span><span>          </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[m a] -&gt; m [a]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; m a -&gt; [m a]
forall a. Int -&gt; a -&gt; [a]
</span><a href="../../base/src/GHC.List.html#replicate"><span class="hs-identifier hs-var">replicate</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679624075"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624074"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-141"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#count"><span class="hs-pragma hs-type">count</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-142"></span><span>
</span><span id="line-143"></span><span class="hs-comment">-- | @chainr p op x@ parses /zero/ or more occurrences of @p@,</span><span>
</span><span id="line-144"></span><span class="hs-comment">-- separated by @op@ Returns a value obtained by a /right/ associative</span><span>
</span><span id="line-145"></span><span class="hs-comment">-- application of all functions returned by @op@ to the values returned</span><span>
</span><span id="line-146"></span><span class="hs-comment">-- by @p@. If there are no occurrences of @p@, the value @x@ is</span><span>
</span><span id="line-147"></span><span class="hs-comment">-- returned.</span><span>
</span><span id="line-148"></span><span id="local-6989586621679624483"><span id="local-6989586621679624484"><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr"><span class="hs-identifier hs-type">chainr</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624484"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624484"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624484"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624484"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624483"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-149"></span><span id="chainr"><span class="annot"><span class="annottext">chainr :: forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainr"><span class="hs-identifier hs-var hs-var">chainr</span></a></span></span><span> </span><span id="local-6989586621679624065"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624065"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624064"><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624064"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span id="local-6989586621679624063"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624063"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainr1"><span class="hs-identifier hs-var">chainr1</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624065"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624064"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; m a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624063"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-150"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr"><span class="hs-pragma hs-type">chainr</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-151"></span><span>
</span><span id="line-152"></span><span class="hs-comment">-- | @chainl p op x@ parses /zero/ or more occurrences of @p@,</span><span>
</span><span id="line-153"></span><span class="hs-comment">-- separated by @op@. Returns a value obtained by a /left/ associative</span><span>
</span><span id="line-154"></span><span class="hs-comment">-- application of all functions returned by @op@ to the values returned</span><span>
</span><span id="line-155"></span><span class="hs-comment">-- by @p@. If there are zero occurrences of @p@, the value @x@ is</span><span>
</span><span id="line-156"></span><span class="hs-comment">-- returned.</span><span>
</span><span id="line-157"></span><span id="local-6989586621679624061"><span id="local-6989586621679624062"><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl"><span class="hs-identifier hs-type">chainl</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624062"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624062"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624062"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624062"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624061"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-158"></span><span id="chainl"><span class="annot"><span class="annottext">chainl :: forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainl"><span class="hs-identifier hs-var hs-var">chainl</span></a></span></span><span> </span><span id="local-6989586621679624055"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624055"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624054"><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624054"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span id="local-6989586621679624053"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624053"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainl1"><span class="hs-identifier hs-var">chainl1</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624055"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624054"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a -&gt; m a
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; m a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624053"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-159"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl"><span class="hs-pragma hs-type">chainl</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-160"></span><span>
</span><span id="line-161"></span><span class="hs-comment">-- | @chainl1 p op x@ parses /one/ or more occurrences of @p@,</span><span>
</span><span id="line-162"></span><span class="hs-comment">-- separated by @op@ Returns a value obtained by a /left/ associative</span><span>
</span><span id="line-163"></span><span class="hs-comment">-- application of all functions returned by @op@ to the values returned</span><span>
</span><span id="line-164"></span><span class="hs-comment">-- by @p@. . This parser can for example be used to eliminate left</span><span>
</span><span id="line-165"></span><span class="hs-comment">-- recursion which typically occurs in expression grammars.</span><span>
</span><span id="line-166"></span><span class="hs-comment">--</span><span>
</span><span id="line-167"></span><span class="hs-comment">-- &gt;  expr   = term   `chainl1` addop</span><span>
</span><span id="line-168"></span><span class="hs-comment">-- &gt;  term   = factor `chainl1` mulop</span><span>
</span><span id="line-169"></span><span class="hs-comment">-- &gt;  factor = parens expr &lt;|&gt; integer</span><span>
</span><span id="line-170"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-171"></span><span class="hs-comment">-- &gt;  mulop  = (*) &lt;$ symbol &quot;*&quot;</span><span>
</span><span id="line-172"></span><span class="hs-comment">-- &gt;       &lt;|&gt; div &lt;$ symbol &quot;/&quot;</span><span>
</span><span id="line-173"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-174"></span><span class="hs-comment">-- &gt;  addop  = (+) &lt;$ symbol &quot;+&quot;</span><span>
</span><span id="line-175"></span><span class="hs-comment">-- &gt;       &lt;|&gt; (-) &lt;$ symbol &quot;-&quot;</span><span>
</span><span id="line-176"></span><span id="local-6989586621679624051"><span id="local-6989586621679624052"><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl1"><span class="hs-identifier hs-type">chainl1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624051"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679624051"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624051"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624051"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624052"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624051"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-177"></span><span id="chainl1"><span class="annot"><span class="annottext">chainl1 :: forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainl1"><span class="hs-identifier hs-var hs-var">chainl1</span></a></span></span><span> </span><span id="local-6989586621679624041"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624041"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624040"><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624040"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624039"><span class="hs-identifier hs-var">scan</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-178"></span><span>  </span><span id="local-6989586621679624039"><span class="annot"><span class="annottext">scan :: m a
</span><a href="#local-6989586621679624039"><span class="hs-identifier hs-var hs-var">scan</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624041"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (a -&gt; a) -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f (a -&gt; b) -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%2A%3E"><span class="hs-operator hs-var">&lt;**&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a)
</span><a href="#local-6989586621679624038"><span class="hs-identifier hs-var">rst</span></a></span><span>
</span><span id="line-179"></span><span>  </span><span id="local-6989586621679624038"><span class="annot"><span class="annottext">rst :: m (a -&gt; a)
</span><a href="#local-6989586621679624038"><span class="hs-identifier hs-var hs-var">rst</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621679624037"><span class="annot"><span class="annottext">a -&gt; a -&gt; a
</span><a href="#local-6989586621679624037"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621679624036"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624036"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span id="local-6989586621679624035"><span class="annot"><span class="annottext">a -&gt; a
</span><a href="#local-6989586621679624035"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span id="local-6989586621679624034"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624034"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; a
</span><a href="#local-6989586621679624035"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
</span><a href="#local-6989586621679624037"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624034"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679624036"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((a -&gt; a -&gt; a) -&gt; a -&gt; (a -&gt; a) -&gt; a -&gt; a)
-&gt; m (a -&gt; a -&gt; a) -&gt; m (a -&gt; (a -&gt; a) -&gt; a -&gt; a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624040"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; (a -&gt; a) -&gt; a -&gt; a) -&gt; m a -&gt; m ((a -&gt; a) -&gt; a -&gt; a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624041"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m ((a -&gt; a) -&gt; a -&gt; a) -&gt; m (a -&gt; a) -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a)
</span><a href="#local-6989586621679624038"><span class="hs-identifier hs-var">rst</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a) -&gt; m (a -&gt; a) -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; a) -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span>
</span><span id="line-180"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainl1"><span class="hs-pragma hs-type">chainl1</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-181"></span><span>
</span><span id="line-182"></span><span class="hs-comment">-- | @chainr1 p op x@ parses /one/ or more occurrences of @p@,</span><span>
</span><span id="line-183"></span><span class="hs-comment">-- separated by @op@ Returns a value obtained by a /right/ associative</span><span>
</span><span id="line-184"></span><span class="hs-comment">-- application of all functions returned by @op@ to the values returned</span><span>
</span><span id="line-185"></span><span class="hs-comment">-- by @p@.</span><span>
</span><span id="line-186"></span><span id="local-6989586621679624479"><span id="local-6989586621679624480"><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr1"><span class="hs-identifier hs-type">chainr1</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624480"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624480"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624479"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624480"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679624479"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624479"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624479"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624480"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624479"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-187"></span><span id="chainr1"><span class="annot"><span class="annottext">chainr1 :: forall (m :: * -&gt; *) a.
Alternative m =&gt;
m a -&gt; m (a -&gt; a -&gt; a) -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#chainr1"><span class="hs-identifier hs-var hs-var">chainr1</span></a></span></span><span> </span><span id="local-6989586621679624024"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624024"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624023"><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624023"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624022"><span class="hs-identifier hs-var">scan</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-188"></span><span>  </span><span id="local-6989586621679624022"><span class="annot"><span class="annottext">scan :: m a
</span><a href="#local-6989586621679624022"><span class="hs-identifier hs-var hs-var">scan</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624024"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m (a -&gt; a) -&gt; m a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f (a -&gt; b) -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%2A%3E"><span class="hs-operator hs-var">&lt;**&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a)
</span><a href="#local-6989586621679624021"><span class="hs-identifier hs-var">rst</span></a></span><span>
</span><span id="line-189"></span><span>  </span><span id="local-6989586621679624021"><span class="annot"><span class="annottext">rst :: m (a -&gt; a)
</span><a href="#local-6989586621679624021"><span class="hs-identifier hs-var hs-var">rst</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a -&gt; a -&gt; a) -&gt; a -&gt; a -&gt; a
forall a b c. (a -&gt; b -&gt; c) -&gt; b -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#flip"><span class="hs-identifier hs-var">flip</span></a></span><span> </span><span class="annot"><span class="annottext">((a -&gt; a -&gt; a) -&gt; a -&gt; a -&gt; a)
-&gt; m (a -&gt; a -&gt; a) -&gt; m (a -&gt; a -&gt; a)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a)
</span><a href="#local-6989586621679624023"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a -&gt; a) -&gt; m a -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624022"><span class="hs-identifier hs-var">scan</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m (a -&gt; a) -&gt; m (a -&gt; a) -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; a) -&gt; m (a -&gt; a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a. a -&gt; a
</span><a href="../../base/src/GHC.Base.html#id"><span class="hs-identifier hs-var">id</span></a></span><span>
</span><span id="line-190"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#chainr1"><span class="hs-pragma hs-type">chainr1</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-191"></span><span>
</span><span id="line-192"></span><span class="hs-comment">-- | @manyTill p end@ applies parser @p@ /zero/ or more times until</span><span>
</span><span id="line-193"></span><span class="hs-comment">-- parser @end@ succeeds. Returns the list of values returned by @p@.</span><span>
</span><span id="line-194"></span><span class="hs-comment">-- This parser can be used to scan comments:</span><span>
</span><span id="line-195"></span><span class="hs-comment">--</span><span>
</span><span id="line-196"></span><span class="hs-comment">-- &gt;  simpleComment   = do{ string &quot;&lt;!--&quot;</span><span>
</span><span id="line-197"></span><span class="hs-comment">-- &gt;                      ; manyTill anyChar (try (string &quot;--&gt;&quot;))</span><span>
</span><span id="line-198"></span><span class="hs-comment">-- &gt;                      }</span><span>
</span><span id="line-199"></span><span class="hs-comment">--</span><span>
</span><span id="line-200"></span><span class="hs-comment">--    Note the overlapping parsers @anyChar@ and @string \&quot;--&gt;\&quot;@, and</span><span>
</span><span id="line-201"></span><span class="hs-comment">--    therefore the use of the 'try' combinator.</span><span>
</span><span id="line-202"></span><span id="local-6989586621679624017"><span id="local-6989586621679624018"><span id="local-6989586621679624019"><span class="annot"><a href="Distribution.Compat.Parsing.html#manyTill"><span class="hs-identifier hs-type">manyTill</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624019"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624019"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624018"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624019"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624017"><span class="hs-identifier hs-type">end</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624019"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679624018"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span></span></span><span>
</span><span id="line-203"></span><span id="manyTill"><span class="annot"><span class="annottext">manyTill :: forall (m :: * -&gt; *) a sep. Alternative m =&gt; m a -&gt; m sep -&gt; m [a]
</span><a href="Distribution.Compat.Parsing.html#manyTill"><span class="hs-identifier hs-var hs-var">manyTill</span></a></span></span><span> </span><span id="local-6989586621679624009"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624009"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679624008"><span class="annot"><span class="annottext">m end
</span><a href="#local-6989586621679624008"><span class="hs-identifier hs-var">end</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m [a]
</span><a href="#local-6989586621679624007"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679624007"><span class="annot"><span class="annottext">go :: m [a]
</span><a href="#local-6989586621679624007"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; m end -&gt; m [a]
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m end
</span><a href="#local-6989586621679624008"><span class="hs-identifier hs-var">end</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m [a] -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%7C%3E"><span class="hs-operator hs-var">&lt;|&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">:</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(a -&gt; [a] -&gt; [a]) -&gt; m a -&gt; m ([a] -&gt; [a])
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679624009"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m ([a] -&gt; [a]) -&gt; m [a] -&gt; m [a]
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m [a]
</span><a href="#local-6989586621679624007"><span class="hs-identifier hs-var">go</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-204"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#manyTill"><span class="hs-pragma hs-type">manyTill</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-205"></span><span>
</span><span id="line-206"></span><span class="hs-keyword">infixr</span><span> </span><span class="hs-number">0</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-type">&lt;?&gt;</span></a></span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span class="hs-comment">-- | Additional functionality needed to describe parsers independent of input type.</span><span>
</span><span id="line-209"></span><span class="hs-keyword">class</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Alternative"><span class="hs-identifier hs-type">Alternative</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span id="Parsing"><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-var">Parsing</span></a></span></span><span> </span><span id="local-6989586621679624462"><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-210"></span><span>  </span><span class="hs-comment">-- | Take a parser that may consume input, and on failure, go back to</span><span>
</span><span id="line-211"></span><span>  </span><span class="hs-comment">-- where we started and fail as if we didn't consume input.</span><span>
</span><span id="line-212"></span><span>  </span><span id="local-6989586621679624458"><span id="try"><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-type">try</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624458"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624458"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-213"></span><span>
</span><span id="line-214"></span><span>  </span><span class="hs-comment">-- | Give a parser a name</span><span>
</span><span id="line-215"></span><span>  </span><span id="local-6989586621679624457"><span id="%3C%3F%3E"><span class="annot"><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-type">(&lt;?&gt;)</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624457"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624457"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-216"></span><span>
</span><span id="line-217"></span><span>  </span><span class="hs-comment">-- | A version of many that discards its input. Specialized because it</span><span>
</span><span id="line-218"></span><span>  </span><span class="hs-comment">-- can often be implemented more cheaply.</span><span>
</span><span id="line-219"></span><span>  </span><span id="local-6989586621679624461"><span id="skipMany"><span class="annot"><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-type">skipMany</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624461"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-220"></span><span>  </span><span id="local-6989586621679624002"><span class="annot"><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var hs-var">skipMany</span></a></span><span> </span><span id="local-6989586621679623996"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623996"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">() -&gt; m [a] -&gt; m ()
forall (f :: * -&gt; *) a b. Functor f =&gt; a -&gt; f b -&gt; f a
</span><a href="../../base/src/GHC.Base.html#%3C%24"><span class="hs-operator hs-var">&lt;$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m [a]
forall (f :: * -&gt; *) a. Alternative f =&gt; f a -&gt; f [a]
</span><a href="../../base/src/GHC.Base.html#many"><span class="hs-identifier hs-var">many</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623996"><span class="hs-identifier hs-var">p</span></a></span></span><span>
</span><span id="line-221"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-pragma hs-type">skipMany</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-222"></span><span>
</span><span id="line-223"></span><span>  </span><span class="hs-comment">-- | @skipSome p@ applies the parser @p@ /one/ or more times, skipping</span><span>
</span><span id="line-224"></span><span>  </span><span class="hs-comment">-- its result. (aka skipMany1 in parsec)</span><span>
</span><span id="line-225"></span><span>  </span><span id="local-6989586621679623995"><span id="skipSome"><span class="annot"><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-type">skipSome</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679623995"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-226"></span><span>  </span><span id="local-6989586621679623993"><span class="annot"><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-identifier hs-var hs-var">skipSome</span></a></span><span> </span><span id="local-6989586621679623988"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623988"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623988"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m () -&gt; m ()
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623988"><span class="hs-identifier hs-var">p</span></a></span></span><span>
</span><span id="line-227"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipSome"><span class="hs-pragma hs-type">skipSome</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-228"></span><span>
</span><span id="line-229"></span><span>  </span><span class="hs-comment">-- | Used to emit an error on an unexpected token</span><span>
</span><span id="line-230"></span><span>  </span><span id="local-6989586621679624456"><span id="unexpected"><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-type">unexpected</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624456"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-231"></span><span>
</span><span id="line-232"></span><span>  </span><span class="hs-comment">-- | This parser only succeeds at the end of the input. This is not a</span><span>
</span><span id="line-233"></span><span>  </span><span class="hs-comment">-- primitive parser but it is defined using 'notFollowedBy'.</span><span>
</span><span id="line-234"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-235"></span><span>  </span><span class="hs-comment">-- &gt;  eof  = notFollowedBy anyChar &lt;?&gt; &quot;end of input&quot;</span><span>
</span><span id="line-236"></span><span>  </span><span id="eof"><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-type">eof</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-237"></span><span>
</span><span id="line-238"></span><span>  </span><span class="hs-comment">-- | @notFollowedBy p@ only succeeds when parser @p@ fails. This parser</span><span>
</span><span id="line-239"></span><span>  </span><span class="hs-comment">-- does not consume any input. This parser can be used to implement the</span><span>
</span><span id="line-240"></span><span>  </span><span class="hs-comment">-- \'longest match\' rule. For example, when recognizing keywords (for</span><span>
</span><span id="line-241"></span><span>  </span><span class="hs-comment">-- example @let@), we want to make sure that a keyword is not followed</span><span>
</span><span id="line-242"></span><span>  </span><span class="hs-comment">-- by a legal identifier character, in which case the keyword is</span><span>
</span><span id="line-243"></span><span>  </span><span class="hs-comment">-- actually an identifier (for example @lets@). We can program this</span><span>
</span><span id="line-244"></span><span>  </span><span class="hs-comment">-- behaviour as follows:</span><span>
</span><span id="line-245"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-246"></span><span>  </span><span class="hs-comment">-- &gt;  keywordLet  = try $ string &quot;let&quot; &lt;* notFollowedBy alphaNum</span><span>
</span><span id="line-247"></span><span>  </span><span id="local-6989586621679624455"><span id="notFollowedBy"><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-type">notFollowedBy</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624455"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624455"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679624462"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-248"></span><span>
</span><span id="line-249"></span><span id="local-6989586621679624450"><span id="local-6989586621679624451"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623976"><span id="local-6989586621679623978"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624451"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624451"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-type">Lazy.StateT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624450"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624451"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-250"></span><span>  </span><span id="local-6989586621679623970"><span class="annot"><span class="annottext">try :: forall a. StateT s m a -&gt; StateT s m a
</span><a href="#local-6989586621679623970"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-type">Lazy.StateT</span></a></span><span> </span><span id="local-6989586621679623968"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623968"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m (a, s)) -&gt; StateT s m a
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-var">Lazy.StateT</span></a></span><span> </span><span class="annot"><span class="annottext">((s -&gt; m (a, s)) -&gt; StateT s m a)
-&gt; (s -&gt; m (a, s)) -&gt; StateT s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s) -&gt; m (a, s)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(m (a, s) -&gt; m (a, s)) -&gt; (s -&gt; m (a, s)) -&gt; s -&gt; m (a, s)
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623968"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-251"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-252"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-type">Lazy.StateT</span></a></span><span> </span><span id="local-6989586621679623965"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623965"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623964"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. StateT s m a -&gt; String -&gt; StateT s m a
</span><a href="#local-6989586621679623964"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623963"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623963"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m (a, s)) -&gt; StateT s m a
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-var">Lazy.StateT</span></a></span><span> </span><span class="annot"><span class="annottext">((s -&gt; m (a, s)) -&gt; StateT s m a)
-&gt; (s -&gt; m (a, s)) -&gt; StateT s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623962"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623962"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623965"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623962"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s) -&gt; String -&gt; m (a, s)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623963"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-253"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-254"></span><span>  </span><span id="local-6989586621679623957"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; StateT s m a
</span><a href="#local-6989586621679623957"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; StateT s m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; StateT s m a) -&gt; (String -&gt; m a) -&gt; String -&gt; StateT s m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-255"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-256"></span><span>  </span><span id="local-6989586621679623953"><span class="annot"><span class="annottext">eof :: StateT s m ()
</span><a href="#local-6989586621679623953"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; StateT s m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-257"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-258"></span><span>  </span><span id="local-6989586621679623946"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; StateT s m a -&gt; StateT s m ()
</span><a href="#local-6989586621679623946"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-type">Lazy.StateT</span></a></span><span> </span><span id="local-6989586621679623945"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623945"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m ((), s)) -&gt; StateT s m ()
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Lazy.html#StateT"><span class="hs-identifier hs-var">Lazy.StateT</span></a></span><span>
</span><span id="line-259"></span><span>    </span><span class="annot"><span class="annottext">((s -&gt; m ((), s)) -&gt; StateT s m ())
-&gt; (s -&gt; m ((), s)) -&gt; StateT s m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623944"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623944"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a, s) -&gt; a
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">((a, s) -&gt; a) -&gt; m (a, s) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623945"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623944"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m ((), s) -&gt; m ((), s)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">((), s) -&gt; m ((), s)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623944"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-260"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span id="local-6989586621679624422"><span id="local-6989586621679624423"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623935"><span id="local-6989586621679623937"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624423"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624423"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">Strict.StateT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624422"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624423"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-263"></span><span>  </span><span id="local-6989586621679623930"><span class="annot"><span class="annottext">try :: forall a. StateT s m a -&gt; StateT s m a
</span><a href="#local-6989586621679623930"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">Strict.StateT</span></a></span><span> </span><span id="local-6989586621679623928"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623928"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m (a, s)) -&gt; StateT s m a
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-var">Strict.StateT</span></a></span><span> </span><span class="annot"><span class="annottext">((s -&gt; m (a, s)) -&gt; StateT s m a)
-&gt; (s -&gt; m (a, s)) -&gt; StateT s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s) -&gt; m (a, s)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(m (a, s) -&gt; m (a, s)) -&gt; (s -&gt; m (a, s)) -&gt; s -&gt; m (a, s)
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623928"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-264"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-265"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">Strict.StateT</span></a></span><span> </span><span id="local-6989586621679623926"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623926"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623925"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. StateT s m a -&gt; String -&gt; StateT s m a
</span><a href="#local-6989586621679623925"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623924"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623924"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m (a, s)) -&gt; StateT s m a
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-var">Strict.StateT</span></a></span><span> </span><span class="annot"><span class="annottext">((s -&gt; m (a, s)) -&gt; StateT s m a)
-&gt; (s -&gt; m (a, s)) -&gt; StateT s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623923"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623923"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623926"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623923"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s) -&gt; String -&gt; m (a, s)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623924"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-266"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-267"></span><span>  </span><span id="local-6989586621679623918"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; StateT s m a
</span><a href="#local-6989586621679623918"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; StateT s m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; StateT s m a) -&gt; (String -&gt; m a) -&gt; String -&gt; StateT s m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-268"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-269"></span><span>  </span><span id="local-6989586621679623914"><span class="annot"><span class="annottext">eof :: StateT s m ()
</span><a href="#local-6989586621679623914"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; StateT s m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-270"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-271"></span><span>  </span><span id="local-6989586621679623907"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; StateT s m a -&gt; StateT s m ()
</span><a href="#local-6989586621679623907"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-type">Strict.StateT</span></a></span><span> </span><span id="local-6989586621679623906"><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623906"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(s -&gt; m ((), s)) -&gt; StateT s m ()
forall s (m :: * -&gt; *) a. (s -&gt; m (a, s)) -&gt; StateT s m a
</span><a href="../../transformers/src/Control.Monad.Trans.State.Strict.html#StateT"><span class="hs-identifier hs-var">Strict.StateT</span></a></span><span>
</span><span id="line-272"></span><span>    </span><span class="annot"><span class="annottext">((s -&gt; m ((), s)) -&gt; StateT s m ())
-&gt; (s -&gt; m ((), s)) -&gt; StateT s m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623905"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623905"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a, s) -&gt; a
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">((a, s) -&gt; a) -&gt; m (a, s) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">s -&gt; m (a, s)
</span><a href="#local-6989586621679623906"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623905"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; m ((), s) -&gt; m ((), s)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">((), s) -&gt; m ((), s)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623905"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-273"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-274"></span><span>
</span><span id="line-275"></span><span id="local-6989586621679624410"><span id="local-6989586621679624411"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623897"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624410"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624411"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-276"></span><span>  </span><span id="local-6989586621679623892"><span class="annot"><span class="annottext">try :: forall a. ReaderT e m a -&gt; ReaderT e m a
</span><a href="#local-6989586621679623892"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span id="local-6989586621679623890"><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623890"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(e -&gt; m a) -&gt; ReaderT e m a
forall r (m :: * -&gt; *) a. (r -&gt; m a) -&gt; ReaderT r m a
</span><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-var">ReaderT</span></a></span><span> </span><span class="annot"><span class="annottext">((e -&gt; m a) -&gt; ReaderT e m a) -&gt; (e -&gt; m a) -&gt; ReaderT e m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m a) -&gt; (e -&gt; m a) -&gt; e -&gt; m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623890"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-277"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-278"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span id="local-6989586621679623888"><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623888"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623887"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. ReaderT e m a -&gt; String -&gt; ReaderT e m a
</span><a href="#local-6989586621679623887"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623886"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623886"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(e -&gt; m a) -&gt; ReaderT e m a
forall r (m :: * -&gt; *) a. (r -&gt; m a) -&gt; ReaderT r m a
</span><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-var">ReaderT</span></a></span><span> </span><span class="annot"><span class="annottext">((e -&gt; m a) -&gt; ReaderT e m a) -&gt; (e -&gt; m a) -&gt; ReaderT e m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623885"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679623885"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623888"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679623885"><span class="hs-identifier hs-var">e</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623886"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-279"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-280"></span><span>  </span><span id="local-6989586621679623883"><span class="annot"><span class="annottext">skipMany :: forall a. ReaderT e m a -&gt; ReaderT e m ()
</span><a href="#local-6989586621679623883"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipMany</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span id="local-6989586621679623882"><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623882"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(e -&gt; m ()) -&gt; ReaderT e m ()
forall r (m :: * -&gt; *) a. (r -&gt; m a) -&gt; ReaderT r m a
</span><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-var">ReaderT</span></a></span><span> </span><span class="annot"><span class="annottext">((e -&gt; m ()) -&gt; ReaderT e m ()) -&gt; (e -&gt; m ()) -&gt; ReaderT e m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m ()) -&gt; (e -&gt; m a) -&gt; e -&gt; m ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623882"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-281"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-pragma hs-type">skipMany</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-282"></span><span>  </span><span id="local-6989586621679623877"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; ReaderT e m a
</span><a href="#local-6989586621679623877"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; ReaderT e m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; ReaderT e m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; ReaderT e m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-283"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-284"></span><span>  </span><span id="local-6989586621679623873"><span class="annot"><span class="annottext">eof :: ReaderT e m ()
</span><a href="#local-6989586621679623873"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; ReaderT e m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-285"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-286"></span><span>  </span><span id="local-6989586621679623869"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; ReaderT e m a -&gt; ReaderT e m ()
</span><a href="#local-6989586621679623869"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-type">ReaderT</span></a></span><span> </span><span id="local-6989586621679623868"><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623868"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(e -&gt; m ()) -&gt; ReaderT e m ()
forall r (m :: * -&gt; *) a. (r -&gt; m a) -&gt; ReaderT r m a
</span><a href="../../transformers/src/Control.Monad.Trans.Reader.html#ReaderT"><span class="hs-identifier hs-var">ReaderT</span></a></span><span> </span><span class="annot"><span class="annottext">((e -&gt; m ()) -&gt; ReaderT e m ()) -&gt; (e -&gt; m ()) -&gt; ReaderT e m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m ()) -&gt; (e -&gt; m a) -&gt; e -&gt; m ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">e -&gt; m a
</span><a href="#local-6989586621679623868"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-287"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-288"></span><span>
</span><span id="line-289"></span><span id="local-6989586621679624397"><span id="local-6989586621679624398"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623859"><span id="local-6989586621679623861"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624398"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624398"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624397"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-type">Strict.WriterT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624397"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624398"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-290"></span><span>  </span><span id="local-6989586621679623854"><span class="annot"><span class="annottext">try :: forall a. WriterT w m a -&gt; WriterT w m a
</span><a href="#local-6989586621679623854"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-type">Strict.WriterT</span></a></span><span> </span><span id="local-6989586621679623852"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623852"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; WriterT w m a
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-var">Strict.WriterT</span></a></span><span> </span><span class="annot"><span class="annottext">(m (a, w) -&gt; WriterT w m a) -&gt; m (a, w) -&gt; WriterT w m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; m (a, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623852"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-291"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-292"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-type">Strict.WriterT</span></a></span><span> </span><span id="local-6989586621679623850"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623850"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623849"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. WriterT w m a -&gt; String -&gt; WriterT w m a
</span><a href="#local-6989586621679623849"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623848"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623848"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; WriterT w m a
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-var">Strict.WriterT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623850"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; String -&gt; m (a, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623848"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-293"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-294"></span><span>  </span><span id="local-6989586621679623843"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; WriterT w m a
</span><a href="#local-6989586621679623843"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; WriterT w m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; WriterT w m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; WriterT w m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-295"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-296"></span><span>  </span><span id="local-6989586621679623839"><span class="annot"><span class="annottext">eof :: WriterT w m ()
</span><a href="#local-6989586621679623839"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; WriterT w m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-297"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-298"></span><span>  </span><span id="local-6989586621679623831"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; WriterT w m a -&gt; WriterT w m ()
</span><a href="#local-6989586621679623831"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-type">Strict.WriterT</span></a></span><span> </span><span id="local-6989586621679623830"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623830"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m ((), w) -&gt; WriterT w m ()
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Strict.html#WriterT"><span class="hs-identifier hs-var">Strict.WriterT</span></a></span><span>
</span><span id="line-299"></span><span>    </span><span class="annot"><span class="annottext">(m ((), w) -&gt; WriterT w m ()) -&gt; m ((), w) -&gt; WriterT w m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a, w) -&gt; a
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">((a, w) -&gt; a) -&gt; m (a, w) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623830"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; (() -&gt; m ((), w)) -&gt; m ((), w)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623829"><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623829"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">((), w) -&gt; m ((), w)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623829"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">w
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-300"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-301"></span><span>
</span><span id="line-302"></span><span id="local-6989586621679624382"><span id="local-6989586621679624383"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623820"><span id="local-6989586621679623822"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624383"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624383"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624382"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-type">Lazy.WriterT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624382"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624383"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-303"></span><span>  </span><span id="local-6989586621679623815"><span class="annot"><span class="annottext">try :: forall a. WriterT w m a -&gt; WriterT w m a
</span><a href="#local-6989586621679623815"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-type">Lazy.WriterT</span></a></span><span> </span><span id="local-6989586621679623813"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623813"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; WriterT w m a
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-var">Lazy.WriterT</span></a></span><span> </span><span class="annot"><span class="annottext">(m (a, w) -&gt; WriterT w m a) -&gt; m (a, w) -&gt; WriterT w m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; m (a, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623813"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-304"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-305"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-type">Lazy.WriterT</span></a></span><span> </span><span id="local-6989586621679623811"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623811"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623810"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. WriterT w m a -&gt; String -&gt; WriterT w m a
</span><a href="#local-6989586621679623810"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623809"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623809"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; WriterT w m a
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-var">Lazy.WriterT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623811"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w) -&gt; String -&gt; m (a, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623809"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-306"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-307"></span><span>  </span><span id="local-6989586621679623804"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; WriterT w m a
</span><a href="#local-6989586621679623804"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; WriterT w m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; WriterT w m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; WriterT w m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-308"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-309"></span><span>  </span><span id="local-6989586621679623800"><span class="annot"><span class="annottext">eof :: WriterT w m ()
</span><a href="#local-6989586621679623800"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; WriterT w m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-310"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-311"></span><span>  </span><span id="local-6989586621679623792"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; WriterT w m a -&gt; WriterT w m ()
</span><a href="#local-6989586621679623792"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-type">Lazy.WriterT</span></a></span><span> </span><span id="local-6989586621679623791"><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623791"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m ((), w) -&gt; WriterT w m ()
forall w (m :: * -&gt; *) a. m (a, w) -&gt; WriterT w m a
</span><a href="../../transformers/src/Control.Monad.Trans.Writer.Lazy.html#WriterT"><span class="hs-identifier hs-var">Lazy.WriterT</span></a></span><span>
</span><span id="line-312"></span><span>    </span><span class="annot"><span class="annottext">(m ((), w) -&gt; WriterT w m ()) -&gt; m ((), w) -&gt; WriterT w m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a, w) -&gt; a
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">((a, w) -&gt; a) -&gt; m (a, w) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, w)
</span><a href="#local-6989586621679623791"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; (() -&gt; m ((), w)) -&gt; m ((), w)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623790"><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623790"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">((), w) -&gt; m ((), w)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623790"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">w
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-313"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span><span>
</span><span id="line-314"></span><span>
</span><span id="line-315"></span><span id="local-6989586621679624366"><span id="local-6989586621679624367"><span id="local-6989586621679624368"><span id="local-6989586621679624369"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623781"><span id="local-6989586621679623783"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624369"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624369"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624368"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-type">Lazy.RWST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624367"><span class="hs-identifier hs-type">r</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624368"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624366"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624369"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-316"></span><span>  </span><span id="local-6989586621679623776"><span class="annot"><span class="annottext">try :: forall a. RWST r w s m a -&gt; RWST r w s m a
</span><a href="#local-6989586621679623776"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-type">Lazy.RWST</span></a></span><span> </span><span id="local-6989586621679623774"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623774"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-var">Lazy.RWST</span></a></span><span> </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a)
-&gt; (r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623773"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623773"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623772"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623772"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m (a, s, w) -&gt; m (a, s, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623774"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623773"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623772"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-317"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-318"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-type">Lazy.RWST</span></a></span><span> </span><span id="local-6989586621679623770"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623770"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623769"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. RWST r w s m a -&gt; String -&gt; RWST r w s m a
</span><a href="#local-6989586621679623769"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623768"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623768"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-var">Lazy.RWST</span></a></span><span> </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a)
-&gt; (r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623767"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623767"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623766"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623766"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623770"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623767"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623766"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s, w) -&gt; String -&gt; m (a, s, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623768"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-319"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-320"></span><span>  </span><span id="local-6989586621679623761"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; RWST r w s m a
</span><a href="#local-6989586621679623761"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; RWST r w s m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; RWST r w s m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; RWST r w s m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-321"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-322"></span><span>  </span><span id="local-6989586621679623757"><span class="annot"><span class="annottext">eof :: RWST r w s m ()
</span><a href="#local-6989586621679623757"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; RWST r w s m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-323"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-324"></span><span>  </span><span id="local-6989586621679623749"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; RWST r w s m a -&gt; RWST r w s m ()
</span><a href="#local-6989586621679623749"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-type">Lazy.RWST</span></a></span><span> </span><span id="local-6989586621679623748"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623748"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ()
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Lazy.html#RWST"><span class="hs-identifier hs-var">Lazy.RWST</span></a></span><span>
</span><span id="line-325"></span><span>    </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ())
-&gt; (r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623747"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623747"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623746"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623746"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679623745"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679623745"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">s
</span><span class="hs-identifier">_</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">w
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679623745"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((a, s, w) -&gt; a) -&gt; m (a, s, w) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623748"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623747"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623746"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; (() -&gt; m ((), s, w)) -&gt; m ((), s, w)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623744"><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623744"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">((), s, w) -&gt; m ((), s, w)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623744"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623746"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">w
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-326"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span></span></span><span>
</span><span id="line-327"></span><span>
</span><span id="line-328"></span><span id="local-6989586621679624346"><span id="local-6989586621679624347"><span id="local-6989586621679624348"><span id="local-6989586621679624349"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623735"><span id="local-6989586621679623737"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624349"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#MonadPlus"><span class="hs-identifier hs-type">MonadPlus</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624349"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monoid"><span class="hs-identifier hs-type">Monoid</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624348"><span class="hs-identifier hs-type">w</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-type">Strict.RWST</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624347"><span class="hs-identifier hs-type">r</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624348"><span class="hs-identifier hs-type">w</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624346"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624349"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-329"></span><span>  </span><span id="local-6989586621679623730"><span class="annot"><span class="annottext">try :: forall a. RWST r w s m a -&gt; RWST r w s m a
</span><a href="#local-6989586621679623730"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-type">Strict.RWST</span></a></span><span> </span><span id="local-6989586621679623728"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623728"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-var">Strict.RWST</span></a></span><span> </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a)
-&gt; (r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623727"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623727"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623726"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623726"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m (a, s, w) -&gt; m (a, s, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623728"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623727"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623726"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-330"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-331"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-type">Strict.RWST</span></a></span><span> </span><span id="local-6989586621679623724"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623724"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623723"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. RWST r w s m a -&gt; String -&gt; RWST r w s m a
</span><a href="#local-6989586621679623723"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623722"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623722"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-var">Strict.RWST</span></a></span><span> </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a)
-&gt; (r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623721"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623721"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623720"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623720"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623724"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623721"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623720"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">m (a, s, w) -&gt; String -&gt; m (a, s, w)
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623722"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-332"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-333"></span><span>  </span><span id="local-6989586621679623715"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; RWST r w s m a
</span><a href="#local-6989586621679623715"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; RWST r w s m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; RWST r w s m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; RWST r w s m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-334"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-335"></span><span>  </span><span id="local-6989586621679623711"><span class="annot"><span class="annottext">eof :: RWST r w s m ()
</span><a href="#local-6989586621679623711"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; RWST r w s m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-336"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-337"></span><span>  </span><span id="local-6989586621679623703"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; RWST r w s m a -&gt; RWST r w s m ()
</span><a href="#local-6989586621679623703"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-type">Strict.RWST</span></a></span><span> </span><span id="local-6989586621679623702"><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623702"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ()
forall r w s (m :: * -&gt; *) a.
(r -&gt; s -&gt; m (a, s, w)) -&gt; RWST r w s m a
</span><a href="../../transformers/src/Control.Monad.Trans.RWS.Strict.html#RWST"><span class="hs-identifier hs-var">Strict.RWST</span></a></span><span>
</span><span id="line-338"></span><span>    </span><span class="annot"><span class="annottext">((r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ())
-&gt; (r -&gt; s -&gt; m ((), s, w)) -&gt; RWST r w s m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623701"><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623701"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span id="local-6989586621679623700"><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623700"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679623699"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679623699"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">s
</span><span class="hs-identifier">_</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">w
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679623699"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">((a, s, w) -&gt; a) -&gt; m (a, s, w) -&gt; m a
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">r -&gt; s -&gt; m (a, s, w)
</span><a href="#local-6989586621679623702"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">r
</span><a href="#local-6989586621679623701"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623700"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m () -&gt; (() -&gt; m ((), s, w)) -&gt; m ((), s, w)
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679623698"><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623698"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">((), s, w) -&gt; m ((), s, w)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">()
</span><a href="#local-6989586621679623698"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">s
</span><a href="#local-6989586621679623700"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">w
forall a. Monoid a =&gt; a
</span><a href="../../base/src/GHC.Base.html#mempty"><span class="hs-identifier hs-var">mempty</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-339"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span></span></span></span><span>
</span><span id="line-340"></span><span>
</span><span id="line-341"></span><span id="local-6989586621679624332"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679623690"><span class="hs-special">(</span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624332"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#Monad"><span class="hs-identifier hs-type">Monad</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624332"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-type">IdentityT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624332"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-342"></span><span>  </span><span id="local-6989586621679623685"><span class="annot"><span class="annottext">try :: forall a. IdentityT m a -&gt; IdentityT m a
</span><a href="#local-6989586621679623685"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; IdentityT m a
forall {k} (f :: k -&gt; *) (a :: k). f a -&gt; IdentityT f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-var">IdentityT</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; IdentityT m a)
-&gt; (IdentityT m a -&gt; m a) -&gt; IdentityT m a -&gt; IdentityT m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#try"><span class="hs-identifier hs-var">try</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m a) -&gt; (IdentityT m a -&gt; m a) -&gt; IdentityT m a -&gt; m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">IdentityT m a -&gt; m a
forall {k} (f :: k -&gt; *) (a :: k). IdentityT f a -&gt; f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#runIdentityT"><span class="hs-identifier hs-var hs-var">runIdentityT</span></a></span><span>
</span><span id="line-343"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#try"><span class="hs-pragma hs-type">try</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-344"></span><span>  </span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-type">IdentityT</span></a></span><span> </span><span id="local-6989586621679623681"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623681"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679623680"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. IdentityT m a -&gt; String -&gt; IdentityT m a
</span><a href="#local-6989586621679623680"><span class="hs-operator hs-var hs-var hs-var hs-var">&lt;?&gt;</span></a></span></span><span> </span><span id="local-6989586621679623679"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623679"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; IdentityT m a
forall {k} (f :: k -&gt; *) (a :: k). f a -&gt; IdentityT f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-var">IdentityT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623681"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#%3C%3F%3E"><span class="hs-operator hs-var">&lt;?&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679623679"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-345"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">&lt;?&gt;</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-346"></span><span>  </span><span id="local-6989586621679623677"><span class="annot"><span class="annottext">skipMany :: forall a. IdentityT m a -&gt; IdentityT m ()
</span><a href="#local-6989586621679623677"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipMany</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; IdentityT m ()
forall {k} (f :: k -&gt; *) (a :: k). f a -&gt; IdentityT f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-var">IdentityT</span></a></span><span> </span><span class="annot"><span class="annottext">(m () -&gt; IdentityT m ())
-&gt; (IdentityT m a -&gt; m ()) -&gt; IdentityT m a -&gt; IdentityT m ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. Parsing m =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-identifier hs-var">skipMany</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; m ()) -&gt; (IdentityT m a -&gt; m a) -&gt; IdentityT m a -&gt; m ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">IdentityT m a -&gt; m a
forall {k} (f :: k -&gt; *) (a :: k). IdentityT f a -&gt; f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#runIdentityT"><span class="hs-identifier hs-var hs-var">runIdentityT</span></a></span><span>
</span><span id="line-347"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#skipMany"><span class="hs-pragma hs-type">skipMany</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-348"></span><span>  </span><span id="local-6989586621679623672"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; IdentityT m a
</span><a href="#local-6989586621679623672"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m a -&gt; IdentityT m a
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">(m a -&gt; IdentityT m a)
-&gt; (String -&gt; m a) -&gt; String -&gt; IdentityT m a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. Parsing m =&gt; String -&gt; m a
</span><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-identifier hs-var">unexpected</span></a></span><span>
</span><span id="line-349"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#unexpected"><span class="hs-pragma hs-type">unexpected</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-350"></span><span>  </span><span id="local-6989586621679623668"><span class="annot"><span class="annottext">eof :: IdentityT m ()
</span><a href="#local-6989586621679623668"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; IdentityT m ()
forall (t :: (* -&gt; *) -&gt; * -&gt; *) (m :: * -&gt; *) a.
(MonadTrans t, Monad m) =&gt;
m a -&gt; t m a
</span><a href="../../transformers/src/Control.Monad.Trans.Class.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">m ()
forall (m :: * -&gt; *). Parsing m =&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-identifier hs-var">eof</span></a></span><span>
</span><span id="line-351"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#eof"><span class="hs-pragma hs-type">eof</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-352"></span><span>  </span><span id="local-6989586621679623664"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; IdentityT m a -&gt; IdentityT m ()
</span><a href="#local-6989586621679623664"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-type">IdentityT</span></a></span><span> </span><span id="local-6989586621679623663"><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623663"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">m () -&gt; IdentityT m ()
forall {k} (f :: k -&gt; *) (a :: k). f a -&gt; IdentityT f a
</span><a href="../../transformers/src/Control.Monad.Trans.Identity.html#IdentityT"><span class="hs-identifier hs-var">IdentityT</span></a></span><span> </span><span class="annot"><span class="annottext">(m () -&gt; IdentityT m ()) -&gt; m () -&gt; IdentityT m ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">m a -&gt; m ()
forall (m :: * -&gt; *) a. (Parsing m, Show a) =&gt; m a -&gt; m ()
</span><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-identifier hs-var">notFollowedBy</span></a></span><span> </span><span class="annot"><span class="annottext">m a
</span><a href="#local-6989586621679623663"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-353"></span><span>  </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#notFollowedBy"><span class="hs-pragma hs-type">notFollowedBy</span></a></span><span> </span><span class="hs-pragma">#-}</span></span><span>
</span><span id="line-354"></span><span>
</span><span id="line-355"></span><span id="local-6989586621679624308"><span id="local-6989586621679624309"><span id="local-6989586621679624310"><span id="local-6989586621679624311"><span class="hs-keyword">instance</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#Stream"><span class="hs-identifier hs-type">Parsec.Stream</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624311"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624310"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624309"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624309"><span class="hs-identifier hs-type">t</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Distribution.Compat.Parsing.html#Parsing"><span class="hs-identifier hs-type">Parsing</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../parsec/src/Text.Parsec.Prim.html#ParsecT"><span class="hs-identifier hs-type">Parsec.ParsecT</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624311"><span class="hs-identifier hs-type">s</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624308"><span class="hs-identifier hs-type">u</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679624310"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-356"></span><span>  </span><span id="local-6989586621679623649"><span class="annot"><span class="annottext">try :: forall a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="#local-6989586621679623649"><span class="hs-identifier hs-var hs-var hs-var hs-var">try</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m a
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m a
</span><a href="../../parsec/src/Text.Parsec.Prim.html#try"><span class="hs-identifier hs-var">Parsec.try</span></a></span><span>
</span><span id="line-357"></span><span>  </span><span id="local-6989586621679623647"><span class="annot"><span class="annottext">&lt;?&gt; :: forall a. ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="#local-6989586621679623647"><span class="hs-operator hs-var hs-var hs-var hs-var">(&lt;?&gt;)</span></a></span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
forall s u (m :: * -&gt; *) a.
ParsecT s u m a -&gt; String -&gt; ParsecT s u m a
</span><a href="../../parsec/src/Text.Parsec.Prim.html#%3C%3F%3E"><span class="hs-operator hs-var">(Parsec.&lt;?&gt;)</span></a></span><span>
</span><span id="line-358"></span><span>  </span><span id="local-6989586621679623645"><span class="annot"><span class="annottext">skipMany :: forall a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679623645"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipMany</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m ()
forall s u (m :: * -&gt; *) a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="../../parsec/src/Text.Parsec.Prim.html#skipMany"><span class="hs-identifier hs-var">Parsec.skipMany</span></a></span><span>
</span><span id="line-359"></span><span>  </span><span id="local-6989586621679623642"><span class="annot"><span class="annottext">skipSome :: forall a. ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679623642"><span class="hs-identifier hs-var hs-var hs-var hs-var">skipSome</span></a></span></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="../../parsec/src/Text.Parsec.Combinator.html#skipMany1"><span class="hs-identifier hs-var">Parsec.skipMany1</span></a></span><span>
</span><span id="line-360"></span><span>  </span><span id="local-6989586621679623639"><span class="annot"><span class="annottext">unexpected :: forall a. String -&gt; ParsecT s u m a
</span><a href="#local-6989586621679623639"><span class="hs-identifier hs-var hs-var hs-var hs-var">unexpected</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; ParsecT s u m a
forall s (m :: * -&gt; *) t u a.
Stream s m t =&gt;
String -&gt; ParsecT s u m a
</span><a href="../../parsec/src/Text.Parsec.Prim.html#unexpected"><span class="hs-identifier hs-var">Parsec.unexpected</span></a></span><span>
</span><span id="line-361"></span><span>  </span><span id="local-6989586621679623635"><span class="annot"><span class="annottext">eof :: ParsecT s u m ()
</span><a href="#local-6989586621679623635"><span class="hs-identifier hs-var hs-var hs-var hs-var">eof</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m ()
forall s (m :: * -&gt; *) t u.
(Stream s m t, Show t) =&gt;
ParsecT s u m ()
</span><a href="../../parsec/src/Text.Parsec.Combinator.html#eof"><span class="hs-identifier hs-var">Parsec.eof</span></a></span><span>
</span><span id="line-362"></span><span>  </span><span id="local-6989586621679623630"><span class="annot"><span class="annottext">notFollowedBy :: forall a. Show a =&gt; ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="#local-6989586621679623630"><span class="hs-identifier hs-var hs-var hs-var hs-var">notFollowedBy</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ParsecT s u m a -&gt; ParsecT s u m ()
forall s (m :: * -&gt; *) t a u.
(Stream s m t, Show a) =&gt;
ParsecT s u m a -&gt; ParsecT s u m ()
</span><a href="../../parsec/src/Text.Parsec.Combinator.html#notFollowedBy"><span class="hs-identifier hs-var">Parsec.notFollowedBy</span></a></span></span></span></span></span><span>
</span><span id="line-363"></span></pre></body></html>